/* 
 * File:   interface.c
 * Author: nuno
 *
 * Created on February 1, 2012, 7:20 PM
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/*
 * my includes
 */
#include "interface.h"

/*
 * nao esta a funcionar
 */

/*char * read_masked_pass() {
    char * pass = (char*) malloc(PASS_MAX_SIZE);
    char c;
    int size = 0;
    while (size != PASS_MAX_SIZE) //Loop until 'Enter' is pressed
    {
        c = getchar();
        pass[size] = c;
        size++;
        printf("*");
    }
    pass[size] = '\0';
    return pass;
}*/

USER * login(listNode * user_list) {

    // Janela inicial, pede utilizador e password
    char username[USER_MAX_SIZE];
    printf("username:>\t");
    scanf("%s", username);
    printf("password:>\t");
    char pass[PASS_MAX_SIZE];
    scanf("%s", pass);

    // Se o utilizador não exisitir retorna null

    USER * account = check_user(username, user_list);
    if (!account) {
        printf("O utilizador \"%s\" nao existe!\n", username);
        return NULL;
    }

    if (strcmp(pass, account->password) != 0) {
        printf("Password errada!\n");
        return NULL;
    }
    return account;

}

USER * check_login(listNode * user_list) {
    int times = 1;
    USER * typeUser = login(user_list);
    while (times <= 3 && !typeUser) {
        times++;
        typeUser = login(user_list);
    }

    if (times == 4) {
        printf("Atingiu o numero maximo de tentativas\n.");
        exit(1);
    }
    return typeUser;
}

/*
 * 
 */

//Estrutura do menu Student

void show_menuStudent() {
    printf("\t__________________________________________________\n");
    printf("\t|================================================|\n");
    printf("\t|======     Linguagens de Programacao      ======|\n");
    printf("\t|======              ALunos                ======|\n");
    printf("\t|================================================|\n");
    printf("\t|                                                |\n");
    printf("\t|2 ->\tAlterar Dados Proprios                   |\n");
    printf("\t|3 ->\tEscolher Modalidade de Avaliacao         |\n");
    printf("\t|4 ->\tConsultar situacao atual                 |\n");
    printf("\t|5 ->\tLog Out                                  |\n");
    printf("\t|================================================|\n");
    printf("\t|1 ->\tMostrar menu                             |\n");
    printf("\t|0 ->\tSair                                     |\n");
    printf("\t--------------------------------------------------\n");
}

//Função para o menu do tipo STUDENT

int menuStudent(USER * user) {
    int menuItem;
    int show = 1;
    while (menuItem != 0) {
        if (show == 1)
            show_menuStudent();
        show = 0;
        printf("\tInsira uma opcao >: ");
        //retornar o menu sleccionado pelo scanf %d
        scanf("%d", &menuItem);
        switch (menuItem) {
            case 0:
                return 0;
            case 1:
                show = 1;
                break;
            case 2:
                change_self_data(user);

                break;
            case 3:
                choice_evaluationType(user);
                break;
            case 4:
                consult_currentSituation(user);
                //print_user_data(user);
                break;
            case 5:
                //log out
                //main();
                return 1;
                break;

            default:
                printf("Opcao nao reconhecida\n");
                show = 1;
        }
    }
}

float calc_final_grade(float n1, float n2) {
    return 0.4 * n1 + 0.6 * n2;
}

void consult_currentSituation(USER * user) {
    printf("\n\tSituacao actual: ");

    /*float test = user->eval->grade_test;
    float work = user->eval->grade_work;
    if (test >= 7.5 && work >= 9.5) {
        float final = calc_final_grade(test, work);
        if(final < 9.5){
            user->eval->state = DISAPPROVED
        }else{
            user->eval->state = APPROVED;
        }
    }*/
    float test = user->eval->grade_test;
    float work = user->eval->grade_work;
    float test_rec = user->eval->grade_test_rec;
    float work_rec = user->eval->grade_work_rec;

    switch (user->eval->state) {
        case IN_COURSE:
            printf(" Em curso\n\n");
            if (test != -1 && work != -1) {
                printf("\t Teste:\t%.2f\n", test);
                printf("\t Trabalho:\t%.2f\n", work);
                printf("\t NOTA FINAL:\t%.2f\n", calc_final_grade(test, work));
                printf("\t(Recurso)\n\n");
            }
            break;
        case APPROVED:
            printf(" Aprovado\n");

            printf("\t Teste:\t%.2f\n", test);
            printf("\t Trabalho:\t%.2f\n", work);
            printf("\t NOTA FINAL:\t%.2f\n", calc_final_grade(test, work));
            if (test_rec != -1 && work_rec != -1) {
                printf("\t Teste Recurso:\t%.2f\n", test_rec);
                printf("\t Trabalho Recurso:\t%.2f\n", work_rec);
                printf("\t NOTA FINAL Recurso:\t%.2f\n", calc_final_grade(test_rec, work_rec));
            }
            break;
        case DISAPPROVED:
            printf(" Reprovado\n");

            printf("\t Teste:\t%.2f\n", test);
            printf("\t Trabalho:\t%.2f\n", work);
            printf("\t NOTA FINAL:\t%.2f\n", calc_final_grade(test, work));

            printf("\t Teste Recurso:\t%.2f\n", test_rec);
            printf("\t Trabalho Recurso:\t%.2f\n", work_rec);
            printf("\t NOTA FINAL Recurso:\t%.2f\n", calc_final_grade(test_rec, work_rec));
    }
}

void choice_evaluationType(USER * user) {
    // ver se pode alterar
    if (user->eval->mod == CONT) {
        // quer dizer que ja foi alterado e nao pode alterar posteriormente
        printf("Nao pode alterar o tipo de avaliacao.");
        return;
    }
    int test, work;
    test = user->eval->grade_test;
    work = user->eval->grade_work;
    if (test != -1 || work != -1) {
        // as notas ja foram lancadas
        printf("Nao pode alterar o tipo de avaliacao / As notas ja foram lancadas.\n");
        return;
    }
    printf("Pretende alterar para Avaliacao Continua? (s/n)");
    char opt;
    scanf(" %c", &opt);
    if (opt == 's') {
        user->eval->mod = CONT;
    } else if (opt != 'n') {
        printf("Opcao invalida\n");
    }
}


// alterar dados proprios

void change_self_data(USER * user) {
    char opt1, opt2;
    printf("Alterar nome? [y / n]: ");
    scanf(" %c", &opt1);
    if (opt1 == 'y') {
        printf("Insira o novo nome: ");
        scanf("%[ a-zA-Z]s", user->name);
    } else if (opt1 != 'n') {
        printf("Opcao invalida\n");
        return;
    }


    printf("Alterar password? [y / n]: ");
    scanf(" %c", &opt2);
    if (opt2 == 'y') {
        printf("Insira a nova pass: ");
        scanf("%s", user->password);
    } else if (opt1 != 'n') {
        printf("Opcao invalida\n");
        return;
    }

    if (opt1 == 'y' || opt2 == 'y') {
        printf("Os dados foram alterados com sucesso.\n");
        print_user_data(user);
    }
}

//Estrutura do menu Prof

void show_menuProf() {
    printf("\t__________________________________________________\n");
    printf("\t|================================================|\n");
    printf("\t|======     Linguagens de Programacao      ======|\n");
    printf("\t|======              Docentes              ======|\n");
    printf("\t|================================================|\n");
    printf("\t|                                                |\n");
    printf("\t|2 ->\tAlterar Dados Proprios                   |\n");
    printf("\t|3 ->\tInserir Utilizador                       |\n");
    printf("\t|4 ->\tListar Alunos por número mecanografico   |\n");
    printf("\t|5 ->\tRemover Utilizador                       |\n");
    printf("\t|6 ->\tAlterar Dados de Utilizador              |\n");
    printf("\t|7 ->\tConfigurar Listagem Alunos (ordenacao)   |\n");
    printf("\t|8 ->\tListar Alunos segundo opcao de ordenacao |\n");
    printf("\t|9 ->\tConfigurar Listagem Alunos (paginacao)   |\n");
    printf("\t|10->\tListar Alunos segundo opcao de paginacao |\n");
    printf("\t|11->\tListar classificacoes dos alunos         |\n");
    printf("\t|12->\tEstatisticas                             |\n");
    printf("\t|13 ->\tLog Out                                  |\n");
    printf("\t|================================================|\n");
    printf("\t|1 ->\tMostrar menu                             |\n");
    printf("\t|0 ->\tSair                                     |\n");
    printf("\t--------------------------------------------------\n");
}

//Função para o menu do tipo PROF

int menuProf(listNode * list, USER * prof) {
    int menuItem;
    int show = 1;
    USER * n_user;
    int step_page = 5;
    while (menuItem != 0) {
        if (show == 1)
            show_menuProf();
        show = 0;
        printf("\tInsira uma opcao >: ");
        //retornar o menu sleccionado pelo scanf %d
        scanf("%d", &menuItem);
        switch (menuItem) {
            case 0:
                return 0;
                break;
            case 1:
                show = 1;
                break;
            case 2:
                change_self_data(prof);
                break;
            case 3:
                //add_new_user();
                n_user = add_new_user();
                // adicionar novo util. à lista
                list = add_user_sort_mec(n_user, list);
                printf("Utilizador com username \"%s\" criado com sucesso!\n", n_user->username);
                break;
            case 4:
                //list_userByNumber;
                clear();
                list = convertName2Mec(list);
                list_users(list, 0);
                break;
            case 5:
                //del_user(user);
                printf("Insira numero mec. a eliminar: ");
                int num;
                scanf(" %d", &num);
                delete_user(num, list);
                break;
            case 6:
                change_self_data(prof);
                break;
            case 7:
                //choice_userList;
                printf("Escolha metodo de ordenacao:\n");
                printf(" - (1) Numero mecanografico\n");
                printf(" - (2) Nomes\n");
                int opt;
                scanf("%d", &opt);
                if (opt == 1) {

                    list = convertName2Mec(list);

                } else if (opt == 2) {

                    list = convertMec2Name(list);

                } else {
                    printf("Opcao invalida\n");
                }
                break;
            case 8:

                list_users(list, 0);
                break;
            case 9:

                printf("Insira o numero de alunos por pagina:> ");
                scanf("%d", &step_page);
                break;
            case 10:

                list_users_page(list, step_page);
                show = 1;
                break;
            case 11:
                clear();
                list_users(list, 1);
                break;
            case 12:
                stats(list);
                break;
            case 13:
                //log out
                //main();
                return 1;
                break;
            default:
                printf("Opcao nao reconhecida\n");
                show = 1;
        }
    }
}

//Estrutura do menu RegProf

void show_menuRegProf() {
    printf("\t__________________________________________________\n");
    printf("\t|================================================|\n");
    printf("\t|======     Linguagens de Programacao      ======|\n");
    printf("\t|======         Docentes Regentes          ======|\n");
    printf("\t|================================================|\n");
    printf("\t|                                                |\n");
    printf("\t|2 ->\tAlterar Dados Proprios                   |\n");
    printf("\t|3 ->\tInserir Utilizador                       |\n");
    printf("\t|4 ->\tListar Alunos por numero mecanografico   |\n");
    printf("\t|5 ->\tRemover Utilizador                       |\n");
    printf("\t|6 ->\tAlterar Dados de Utilizador              |\n");
    printf("\t|7 ->\tConfigurar Listagem Alunos (ordenacao)   |\n");
    printf("\t|8 ->\tListar Alunos segundo opcao de ordenacao |\n");
    printf("\t|9 ->\tConfigurar Listagem Alunos (paginacao)   |\n");
    printf("\t|10->\tListar Alunos segundo opcao de paginacao |\n");
    printf("\t|11->\tListar classificacoes dos alunos         |\n");
    printf("\t|12->\tLancar Notas                             |\n");
    printf("\t|13->\tEstatisticas                             |\n");
    printf("\t|14 ->\tLog Out                                  |\n");
    printf("\t|================================================|\n");
    printf("\t|1 ->\tMostrar menu                             |\n");
    printf("\t|0 ->\tSair                                     |\n");
    printf("\t-------------------------------------------------\n");
}

//Função para o menu do tipo REGPROF

int menuRegProf(listNode * list, USER * reg_prof) {
    int menuItem;
    int show = 1;
    USER * n_user;
    int step_page = 5;
    do {
        //clear();
        if (show == 1) {
            clear();
            show_menuRegProf();
        }
        show = 0;
        printf("\tInsira uma opcao >: ");
        //retornar o menu sleccionado pelo scanf %d
        scanf("%d", &menuItem);
        switch (menuItem) {
            case 0:
                return 0;
                break;
            case 1:
                show = 1;
                break;
            case 2:
                change_self_data(reg_prof);
                break;
            case 3:
                // ler dados do utilizador
                n_user = add_new_user();
                // adicionar novo util. à lista
                list = add_user_sort_mec(n_user, list);
                printf("Utilizador com username \"%s\" criado com sucesso!\n", n_user->username);
                break;
            case 4:
                //listNode * tmp = list;
                clear();
                list = convertName2Mec(list);
                list_users(list, 0);
                break;
            case 5:
                printf("Insira numero mec. a eliminar: ");
                int num;
                scanf(" %d", &num);
                delete_user(num, list);

                break;
            case 6:
                change_self_data(reg_prof);
                break;
            case 7:
                //choice_userList;
                printf("Escolha metodo de ordenacao:\n");
                printf(" - (1) Numero mecanografico\n");
                printf(" - (2) Nomes\n");
                int opt;
                scanf("%d", &opt);
                if (opt == 1) {

                    list = convertName2Mec(list);

                } else if (opt == 2) {

                    list = convertMec2Name(list);

                } else {
                    printf("Opcao invalida\n");
                }
                break;
            case 8:

                list_users(list, 0);
                break;
            case 9:

                printf("Insira o numero de alunos por pagina:> ");
                scanf("%d", &step_page);
                break;
            case 10:

                list_users_page(list, step_page);
                show = 1;
                break;
            case 11:
                clear();
                list_users(list, 1);
                break;
            case 12:
                insert_notes(list);
                break;
            case 13:
                stats(list);
                break;
            case 14:
                //log out
                //main();
                return 1;
                break;

            default:
                printf("Opcao nao reconhecida\n");
                show = 1;
        }
    } while (menuItem != 0);
}

void insert_notes(listNode * user_list) {
    printf("Insira numero do aluno a alterar: ");
    int num;
    scanf("%d", &num);
    USER * student = check_user_mec(num, user_list);
    if (student == NULL) {
        printf("\tAluno nao existe\n\n");
        return;
    }
    // verificar a epoca 
    float test, work;
    test = student->eval->grade_test;
    work = student->eval->grade_work;
    float test_rec, work_rec;
    test_rec = student->eval->grade_test_rec;
    work_rec = student->eval->grade_work_rec;
    if (test == -1 && work == -1) {
        /*
         * LANCAR NOTAS EPOCA NORMAL (CONTINUA OU FINAL)
         */
        printf("\tInsira notas da epoca normal\n");
        // inserir notas
        float test_read, work_read;
        printf("\tNota teste: ");
        scanf("%f", &test_read);
        printf("\tNota trabalho: ");
        scanf("%f", &work_read);
        if (test_read >= 7.5 && work_read >= 9.5) {
            float final = calc_final_grade(test_read, work_read);
            if (final < 9.5) {
                student->eval->state = IN_COURSE;
            } else {
                student->eval->state = APPROVED;
            }

        } else {
            student->eval->state = IN_COURSE;
        }
        student->eval->grade_test = test_read;
        student->eval->grade_work = work_read;
    } else if (test_rec == -1 && work_rec == -1) {
        /*
         * LANCAR NOTAS EPOCA RECURSO
         */

        printf("\tInsira notas da epoca de recurso\n");
        // inserir notas
        float test_read, work_read;
        printf("\tNota teste: ");
        scanf("%f", &test_read);
        printf("\tNota trabalho: ");
        scanf("%f", &work_read);
        if (test_read >= 7.5 && work_read >= 9.5) {
            float final = calc_final_grade(test_read, work_read);
            if (final < 9.5) {
                student->eval->state = DISAPPROVED;
            } else {
                student->eval->state = APPROVED;
            }

        } else {
            student->eval->state = DISAPPROVED;
        }
        student->eval->grade_test_rec = test_read;
        student->eval->grade_work_rec = work_read;

    } else {
        printf("\n\tLancamentos de notas fechado\n");
    }
}

//Função Adicionar Novo Utilizador

USER * add_new_user() {
    USER * new_user = (USER*) malloc(sizeof (USER));
    // printf 's para o utilizaodr
    printf("Insira o Nome: ");
    scanf(" %[ a-zA-Z]s", new_user->name);
    printf("Insira o User Name: ");
    scanf("%s", new_user->username);
    printf("Insira a Password: ");
    scanf("%s", new_user->password);
    printf("Insira o Numero Mecanografico: ");
    scanf("%d", &(new_user->mec_number));
    printf("Insira o Tipo Utilizador (1 = Aluno; 2 = Docente; 3 = Docente Regente): ");
    int tmp;
    scanf("%d", &tmp);
    new_user->type = tmp;
    EVALUATION * ev;
    switch (tmp) {
        case STUDENT:
            // preencher default values para a avaliacao do estudante
            ev = (EVALUATION*) malloc(sizeof (EVALUATION));
            ev->state = IN_COURSE;
            ev->mod = FINAL;
            ev->grade_test = -1;
            ev->grade_work = -1;
            break;
        default:
            ev = NULL;
    }
    new_user->eval = ev;
    return new_user;
}

//Função alterar dados próprios do estudante

// listar utilizadores

/*
 *
 */

void print_grade(float grade) {
    if (grade == -1)
        printf("N/A\t");
    else
        printf("%.2f\t", grade);
}

void list_users(listNode * list, int flag_grades) {
    listNode * aux = list;
    printf("Num Mec.\tNome\t\t\tUsername\tTipo util.");
    if (flag_grades == 1)
        printf("\t(T)\t(W)\t(F)\t(T rec)\t(W rec)\t(F rec)");
    printf("\n");
    printf("========\t====\t\t\t========\t==========");
    if (flag_grades == 1)
        printf("\t===\t===\t===\t=======\t=======\t=======");
    printf("\n");

    while (aux) {
        USER * u = aux->user;
        if (u->type == STUDENT) {
            print_user(u);

            if (flag_grades == 1) {
                float test, work, test_rec, work_rec;
                test = u->eval->grade_test;
                work = u->eval->grade_work;
                test_rec = u->eval->grade_test_rec;
                work_rec = u->eval->grade_work_rec;
                float final = calc_final_grade(test, work);
                float final_rec = calc_final_grade(test_rec, work_rec);

                print_grade(test);
                print_grade(work);
                print_grade(final);
                print_grade(test_rec);
                print_grade(work_rec);
                print_grade(final_rec);

                //printf("\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f\t%.2f",test, work, final, test_rec, work_rec, final_rec);
            }
            printf("\n");
        }
        aux = aux->next;
    }
}

void clear() {
    int i;
    for (i = 0; i < 50; i++)
        printf("\n");
}

void list_users_page(listNode * list, int step) {
    printf("Paginacao\n");
    listNode * aux = list;
    int i = 1;
    int j;
    int page = 1;
    int size = get_list_size(list); //tamanho da lista
    char cont = 'p';
    while (aux && i <= size && cont == 'p') {
        clear();
        j = 1;
        printf(" -------------- Pagina %d --------------\n", page);
        printf("Num Mec.\tNome\t\t\tUsername\tTipo\n");
        printf("========\t====\t\t\t========\t====\n");
        while (aux && j <= step) {
            if (aux->user->type == STUDENT) {
                print_user(aux->user);
                j++;
            }
            aux = aux->next;
        }
        // validar opcao
        do {
            printf("(proxima=p; sair=s) :> ");
            scanf(" %c", &cont);
            if (cont != 'p' && cont != 's')
                printf("Opcao invalida\n");
        } while (cont != 'p' && cont != 's');
        if (cont == 's')
            break;
        page++;
        i = i + step;
    }
}

// listar utilizador

void print_user(USER * user) {
    printf("%d\t\t", user->mec_number);
    printf("%s\t", user->name);
    printf("%s\t", user->username);

    switch (user->type) {
        case STUDENT:
            printf("ESTUDANTE\t");
            break;
        case PROF:
            printf("DOCENTE\t");
            break;
        case REG_PROF:
            printf("DOCENTE (R)\t");
            break;
    }
}

void print_user_data(USER * user) {
    printf("\n");
    printf("Num. Mec.:\t%d\n", user->mec_number);
    printf("Name:\t\t%s\n", user->name);
    printf("Username:\t%s\n", user->username);
    printf("Tipo:\t\t");
    switch (user->type) {
        case STUDENT:
            printf("ESTUDANTE\n");
            break;
        case PROF:
            printf("DOCENTE\n");
            break;
        case REG_PROF:
            printf("DOCENTE (R)\n");
            break;
    }
}

USER createUser(char * name, char * username, char * pass, int mec, TYPE_USER t) {
    USER u;
    strcpy(u.name, name);
    strcpy(u.username, username);
    strcpy(u.password, pass);
    u.mec_number = mec;
    u.type = t;
    EVALUATION * ev;
    switch (u.type) {
        case STUDENT:
            // preencher default values para a avaliacao do estudante
            ev = (EVALUATION*) malloc(sizeof (EVALUATION));
            ev->state = IN_COURSE;
            ev->mod = FINAL;
            ev->grade_test = -1;
            ev->grade_work = -1;
            ev->grade_test_rec = -1;
            ev->grade_work_rec = -1;
            break;
        default:
            ev = NULL;

    }
    u.eval = ev;
    return u;
}

void stats(listNode * list) {
    // Normal
    // total alunos aprovados

    listNode * aux = list;
    int aprovados_norm = 0;
    int total_norm = 0;
    int aprovados_rec = 0;
    int total_rec = 0;
    while (aux) {
        USER * user = aux->user;
        if (user->type == STUDENT) {
            // ver se existe nota
            float test = user->eval->grade_test;
            float work = user->eval->grade_work;
            if (test != -1 && work != -1) {
                float final = calc_final_grade(test, work);
                if (final >= 9.5 && test >= 7.5 && work >= 9.5) {
                    aprovados_norm++;
                }
                total_norm++;
            }

            float test_rec = user->eval->grade_test_rec;
            float work_rec = user->eval->grade_work_rec;
            if (test_rec != -1 && work_rec != -1) {
                float final = calc_final_grade(test_rec, work_rec);
                if (final >= 9.5 && test_rec >= 7.5 && work_rec >= 9.5) {
                    aprovados_rec++;
                }
                total_rec++;
            }


        }
        aux = aux->next;
    }
    // quando ja percorreu a lista toda apresenta as estatisticas
    printf("NORMAL ==================\n");
    printf("=========================\n");
    printf("Numero de aprovados:\t%d / %d\n", aprovados_norm, total_norm);
    if (total_norm != 0) {
        float perc = ((float) aprovados_norm / (float) total_norm)*100.0;
        printf("Percentagem de aprovados:\t%.1f %%\n\n", perc);
    } else {
        printf("Nenhum nota lancada\n\n");
    }

    printf("RECURSO =================\n");
    printf("=========================\n");
    printf("Numero de aprovados:\t%d / %d\n", aprovados_rec, total_rec);
    if (total_rec != 0) {
        float perc_rec = ((float) aprovados_rec / (float) total_rec)*100.0;
        printf("Percentagem de aprovados:\t%.1f %%\n\n", perc_rec);
    } else {
        printf("Nenhuma nota lancada\n\n");
    }


}

int main(int argc, char** argv) {

    //printf("%d\n", strcmp("André Bruno", "André Carlos"));

    listNode * list = NULL;
    USER user1 = createUser("Nuno Ricardo Nunes", "nunonunes", "xnunox", 8100634, STUDENT);
    USER user2 = createUser("Luis Miguel Neiva", "luisneiva", "xluisx", 8100318, STUDENT);
    USER user3 = createUser("Pedro Miguel Santos", "pedrosantos", "xpedrox", 8100310, STUDENT);
    USER user4 = createUser("Joao Pedro costa", "joaocosta", "xjoaox", 8100320, STUDENT);
    USER user5 = createUser("Tito Miguel Mendes", "titomendes", "xtitox", 8100330, STUDENT);
    USER user6 = createUser("Antonio Jose Silva", "antoniosilva", "xantoniox", 8100340, STUDENT);
    USER user7 = createUser("Joao Pedro costa", "joaocosta", "xjoaox", 8100350, STUDENT);
    USER user8 = createUser("Nuno Andre Graca", "nunograca", "xnunogracax", 8100360, STUDENT);
    USER user9 = createUser("Pedro Manuel Ribeiro", "pedroribeiro", "xpedrox", 8100370, STUDENT);
    USER user10 = createUser("Elisio Jose Fresco", "elisiofresco", "xelisiox", 8100380, STUDENT);
    USER user11 = createUser("Telmo Andre Pereira", "telmopereira", "xtelmox", 8100100, PROF);
    USER user12 = createUser("Alberto Proença", "alberto", "p", 123, REG_PROF);

    list = add_user_sort_mec(&user1, list);
    list = add_user_sort_mec(&user2, list);
    list = add_user_sort_mec(&user3, list);
    list = add_user_sort_mec(&user4, list);
    list = add_user_sort_mec(&user5, list);
    list = add_user_sort_mec(&user6, list);
    list = add_user_sort_mec(&user7, list);
    list = add_user_sort_mec(&user8, list);
    list = add_user_sort_mec(&user9, list);
    list = add_user_sort_mec(&user10, list);
    list = add_user_sort_mec(&user11, list);
    list = add_user_sort_mec(&user12, list);
    USER * user;
    int cont_program;
    do {

        user = check_login(list);

        // Ciclo para validar o tipo de utilizador e mostrar o menu correspondente
        //quando o utilizador entra com sucesso na aplicação,
        switch (user->type) {

            case STUDENT:
                printf("Bem vindo aluno %s\n", user->name);
                cont_program = menuStudent(user);
                break;

            case PROF:
                printf("Bem vindo docente %s\n.", user->name);
                cont_program = menuProf(list, user);
                break;

            case REG_PROF:
                printf("Bem vindo docente regente %s\n.", user->name);
                cont_program = menuRegProf(list, user);
                break;
        }
    } while (cont_program == 1);
    return (EXIT_SUCCESS);
}

